Asinkrone generatorske funkcije: Ovladavanje protokolima asinkrone iteracije

Asinkrono programiranje je kamen temeljac modernog JavaScript razvoja, posebno kada se radi o I/O operacijama poput dohvaćanja podataka s API-ja, čitanja datoteka ili interakcije s bazama podataka. Tradicionalno, oslanjali smo se na Promise i async/await za upravljanje tim asinkronim zadacima. Međutim, asinkrone generatorske funkcije nude moćan i elegantan način za rukovanje asinkronom iteracijom, omogućujući nam obradu tokova podataka asinkrono i učinkovito.

Razumijevanje protokola asinkrone iteracije

Prije nego što se upustite u asinkrone generatorske funkcije, bitno je razumjeti protokole asinkrone iteracije na kojima su one izgrađene. Ti protokoli definiraju kako se asinkroni izvori podataka mogu iterirati na kontroliran i predvidljiv način.

Protokol asinkronog iterabilnog objekta

Protokol asinkronog iterabilnog objekta definira objekt koji se može asinkrono iterirati. Objekt je sukladan ovom protokolu ako ima metodu s ključem Symbol.asyncIterator koja vraća an asinkroni iterator.

Zamislite iterabilni objekt kao popis pjesama. Asinkroni iterabilni objekt je poput popisa pjesama gdje svaka pjesma mora biti učitana (asinkrono) prije nego što se može reproducirati.

Primjer:

            const asyncIterable = {
  [Symbol.asyncIterator]() {
    return {
      next() {
        // Asynchronously fetch the next value
      }
    };
  }
};
            

              
                Copy
              
            
          

Protokol asinkronog iteratora

Protokol asinkronog iteratora definira metode koje asinkroni iterator mora implementirati. Objekt sukladan ovom protokolu mora imati metodu next(), te opcionalno return() i throw() metode.

• next(): Ova metoda vraća Promise koji se razrješava u objekt s dva svojstva: value i done. value sadrži sljedeću vrijednost u nizu, a done je booleanska vrijednost koja označava je li iteracija završena.
• return(): (Opcionalno) Ova metoda vraća Promise koji se razrješava u objekt sa svojstvima value i done. Ona signalizira da se iterator zatvara. To je korisno za oslobađanje resursa.
• throw(): (Opcionalno) Ova metoda vraća Promise koji se odbija s pogreškom. Koristi se za signaliziranje da je došlo do pogreške tijekom iteracije.

Primjer:

            const asyncIterator = {
  next() {
    return new Promise((resolve) => {
      // Asynchronously fetch the next value
      setTimeout(() => {
        resolve({ value: /* some value */, done: false });
      }, 100);
    });
  },
  return() {
    return Promise.resolve({ value: undefined, done: true });
  },
  throw(error) {
    return Promise.reject(error);
  }
};
            

              
                Copy
              
            
          

Uvod u asinkrone generatorske funkcije

Asinkrone generatorske funkcije pružaju prikladniji i čitljiviji način za stvaranje asinkronih iteratora i iterabilnih objekata. One kombiniraju snagu generatora s asinkronosti Promisea.

Sintaksa

Asinkrona generatorska funkcija deklarira se koristeći sintaksu async function*:

            async function* myAsyncGenerator() {
  // Asynchronous operations and yield statements here
}
            

              
                Copy
              
            
          

Ključna riječ yield

Unutar asinkrone generatorske funkcije, ključna riječ yield koristi se za asinkrono produciranje vrijednosti. Svaka yield izjava učinkovito pauzira izvršavanje generatorske funkcije dok se vraćeni Promise ne razriješi.

Primjer:

            async function* fetchUsers() {
  const user1 = await fetch('https://example.com/api/users/1').then(res => res.json());
  yield user1;

  const user2 = await fetch('https://example.com/api/users/2').then(res => res.json());
  yield user2;

  const user3 = await fetch('https://example.com/api/users/3').then(res => res.json());
  yield user3;
}
            

              
                Copy
              
            
          

Konzumiranje asinkronih generatora s for await...of

Možete iterirati kroz vrijednosti koje proizvodi asinkrona generatorska funkcija koristeći petlju for await...of. Ova petlja automatski obrađuje asinkrono razrješavanje Promisea koje vraća generator.

Primjer:

            async function main() {
  for await (const user of fetchUsers()) {
    console.log(user);
  }
}

main();
            

              
                Copy
              
            
          

Praktični slučajevi upotrebe asinkronih generatorskih funkcija

Asinkrone generatorske funkcije izvrsne su u scenarijima koji uključuju asinkrone tokove podataka, kao što su:

1. Strujanje podataka s API-ja

Zamislite dohvaćanje velikog skupa podataka s API-ja koji podržava paginaciju. Umjesto dohvaćanja cijelog skupa podataka odjednom, možete koristiti asinkronu generatorsku funkciju za dohvaćanje i vraćanje stranica podataka inkrementalno.

Primjer (Dohvaćanje paginiranih podataka):

            async function* fetchPaginatedData(url, pageSize = 10) {
  let page = 1;

  while (true) {
    const response = await fetch(`${url}?page=${page}&pageSize=${pageSize}`);
    const data = await response.json();

    if (data.length === 0) {
      return; // No more data
    }

    for (const item of data) {
      yield item;
    }

    page++;
  }
}

async function main() {
  for await (const item of fetchPaginatedData('https://api.example.com/data')) {
    console.log(item);
  }
}

main();
            

              
                Copy
              
            
          

Međunarodni primjer (API za tečaj valuta):

            async function* fetchExchangeRates(currencyPair, startDate, endDate) {
  let currentDate = new Date(startDate);

  while (currentDate <= new Date(endDate)) {
    const dateString = currentDate.toISOString().split('T')[0]; // YYYY-MM-DD
    const url = `https://api.exchangerate.host/${dateString}?base=${currencyPair.substring(0,3)}&symbols=${currencyPair.substring(3,6)}`;
    try {
      const response = await fetch(url);
      const data = await response.json();

      if (data.success) {
        yield {
          date: dateString,
          rate: data.rates[currencyPair.substring(3,6)],
        };
      }

    } catch (error) {
      console.error(`Error fetching data for ${dateString}:`, error);
      // You might want to handle errors differently, e.g., retry or skip the date.
    }

    currentDate.setDate(currentDate.getDate() + 1);
  }
}

async function main() {
  const currencyPair = 'EURUSD';
  const startDate = '2023-01-01';
  const endDate = '2023-01-10';

  for await (const rate of fetchExchangeRates(currencyPair, startDate, endDate)) {
    console.log(rate);
  }
}

main();
            

              
                Copy
              
            
          

Ovaj primjer dohvaća dnevne tečajeve EUR u USD za zadani raspon datuma. Obrađuje potencijalne pogreške tijekom poziva API-ja. Ne zaboravite zamijeniti `https://api.exchangerate.host` s pouzdanom i prikladnom API krajnjom točkom.

2. Obrada velikih datoteka

Kada radite s velikim datotekama, čitanje cijele datoteke u memoriju može biti neučinkovito. Asinkrone generatorske funkcije omogućuju čitanje datoteke redak po redak ili u dijelovima, obrađujući svaki dio asinkrono.

Primjer (Čitanje velike datoteke redak po redak - Node.js):

            const fs = require('fs');
const readline = require('readline');

async function* readLines(filePath) {
  const fileStream = fs.createReadStream(filePath);

  const rl = readline.createInterface({
    input: fileStream,
    crlfDelay: Infinity
  });

  for await (const line of rl) {
    yield line;
  }
}

async function main() {
  for await (const line of readLines('large_file.txt')) {
    // Process each line asynchronously
    console.log(line);
  }
}

main();
            

              
                Copy
              
            
          

Ovaj Node.js primjer demonstrira čitanje datoteke redak po redak koristeći fs.createReadStream i readline.createInterface. Asinkrona generatorska funkcija readLines vraća svaki redak asinkrono.

3. Rukovanje tokovima podataka u stvarnom vremenu (WebSockets, Server-Sent Events)

Asinkrone generatorske funkcije dobro su prikladne za obradu tokova podataka u stvarnom vremenu iz izvora kao što su WebSockets ili Server-Sent Events (SSE). Možete kontinuirano vraćati podatke kako stižu iz toka.

Primjer (Obrada podataka iz WebSocket-a - konceptualno):

            // This is a conceptual example and requires a WebSocket library like 'ws' (Node.js) or the browser's built-in WebSocket API.

async function* processWebSocketStream(url) {
  const websocket = new WebSocket(url);

  websocket.onmessage = (event) => {
    //This needs to be handled outside the generator.
    //Typically, you'd push the event.data into a queue
    //and the generator would asynchronously pull from the queue
    //via a Promise that resolves when data is available.
  };
  websocket.onerror = (error) => {
     //Handle errors.
  };
  websocket.onclose = () => {
    //Handle close.
  }

  //The actual yielding and queue management would happen here,
  //making use of Promises to synchronize between the websocket.onmessage
  //event and the async generator function.
  //This is a simplified illustration.

  //while(true){ //Use this if properly queuing events.
  //  const data = await new Promise((resolve) => {
  //   // Resolve the promise when data is available in the queue.
  //  })
  //  yield data
  //}

}

async function main() {
  // for await (const message of processWebSocketStream('wss://example.com/ws')) {
  //   console.log(message);
  // }
  console.log("WebSocket example - conceptual only. See comments in code for details.");
}

main();
            

              
                Copy
              
            
          

Važne napomene o WebSocket primjeru:

• Priloženi WebSocket primjer je primarno konceptualan jer izravna integracija događajno orijentirane prirode WebSocket-a s asinkronim generatorima zahtijeva pažljivu sinkronizaciju korištenjem Promisea i redova.
• Implementacije u stvarnom svijetu obično uključuju spremanje dolaznih WebSocket poruka u red i korištenje Promisea za signaliziranje asinkronom generatoru kada su novi podaci dostupni. To osigurava da generator ne blokira dok čeka podatke.

4. Implementacija prilagođenih asinkronih iteratora

Asinkrone generatorske funkcije olakšavaju stvaranje prilagođenih asinkronih iteratora za bilo koji asinkroni izvor podataka. Možete definirati vlastitu logiku za dohvaćanje, obradu i vraćanje vrijednosti.

Primjer (Asinkrono generiranje niza brojeva):

            async function* generateNumbers(start, end, delay) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, delay));
    yield i;
  }
}

async function main() {
  for await (const number of generateNumbers(1, 5, 500)) {
    console.log(number);
  }
}

main();
            

              
                Copy
              
            
          

Ovaj primjer generira niz brojeva od start do end, s određenom delay između svakog broja. Redak await new Promise(resolve => setTimeout(resolve, delay)) uvodi asinkronu odgodu.

Rukovanje pogreškama

Rukovanje pogreškama ključno je pri radu s asinkronim generatorskim funkcijama. Možete koristiti try...catch blokove unutar generatorske funkcije za rukovanje pogreškama koje se javljaju tijekom asinkronih operacija.

Primjer (Rukovanje pogreškama u asinkronom generatoru):

            async function* fetchData(url) {
  try {
    const response = await fetch(url);
    const data = await response.json();
    yield data;
  } catch (error) {
    console.error('Error fetching data:', error);
    // You can choose to re-throw the error, yield a default value, or stop the iteration.
    // For example, yield { error: error.message };
    throw error;
  }
}

async function main() {
  try {
    for await (const data of fetchData('https://example.com/api/invalid')) {
      console.log(data);
    }
  } catch (error) {
    console.error('Error during iteration:', error);
  }
}

main();
            

              
                Copy
              
            
          

Ovaj primjer demonstrira kako rukovati pogreškama koje se mogu pojaviti tijekom fetch operacije. try...catch blok hvata sve pogreške i bilježi ih u konzolu. Također možete ponovno baciti pogrešku kako bi je uhvatio potrošač generatora ili vratiti objekt pogreške.

Prednosti korištenja asinkronih generatorskih funkcija

• Poboljšana čitljivost koda: Asinkrone generatorske funkcije čine kod za asinkronu iteraciju čitljivijim i lakšim za održavanje u usporedbi s tradicionalnim pristupima temeljenim na Promiseima.
• Pojednostavljen asinkroni tok kontrole: Pružaju prirodniji i sekvencijalniji način izražavanja asinkrone logike, olakšavajući razumijevanje.
• Učinkovito upravljanje resursima: Omogućuju obradu podataka u dijelovima ili tokovima, smanjujući potrošnju memorije i poboljšavajući performanse, posebno kada se radi s velikim skupovima podataka ili tokovima podataka u stvarnom vremenu.
• Jasna podjela odgovornosti: Razdvajaju logiku za generiranje podataka od logike za konzumiranje podataka, promičući modularnost i ponovnu upotrebu.

Usporedba s drugim asinkronim pristupima

Asinkroni generatori nasuprot Promiseima

Iako su Promisei temeljni za asinkrone operacije, manje su prikladni za rukovanje nizovima asinkronih vrijednosti. Asinkroni generatori pružaju strukturiraniji i učinkovitiji način za iteriranje kroz asinkrone tokove podataka.

Asinkroni generatori nasuprot RxJS Observables

RxJS Observables su još jedan moćan alat za rukovanje asinkronim tokovima podataka. Observables nude naprednije značajke poput operatora za transformiranje, filtriranje i kombiniranje tokova podataka. Međutim, asinkroni generatori su često jednostavniji za korištenje u osnovnim scenarijima asinkrone iteracije.

Kompatibilnost s preglednicima i Node.js-om

Asinkrone generatorske funkcije široko su podržane u modernim preglednicima i Node.js-u. Dostupne su u svim glavnim preglednicima koji podržavaju ES2018 (ECMAScript 2018) i Node.js verzijama 10 i novijim.

Možete koristiti alate poput Babela za transpilaciju vašeg koda u starije verzije JavaScripta ako trebate podržati starija okruženja.

Zaključak

Asinkrone generatorske funkcije su vrijedan dodatak JavaScript asinkronom programskom alatu. One pružaju moćan i elegantan način za rukovanje asinkronom iteracijom, olakšavajući obradu tokova podataka učinkovito i s lakoćom održavanja. Razumijevanjem protokola asinkrone iteracije i sintakse asinkronih generatorskih funkcija, možete iskoristiti njihove prednosti u širokom rasponu aplikacija, od strujanja podataka s API-ja do obrade velikih datoteka i rukovanja tokovima podataka u stvarnom vremenu.

Daljnje učenje

• MDN Web Docs: AsyncGeneratorFunction
• Exploring ES2018: Asynchronous Iteration
• Node.js Dokumentacija: Pogledajte službenu Node.js dokumentaciju za tokove i operacije s datotečnim sustavom.